package com.sdyc.ndmp.cls.engine;

import com.huaban.analysis.jieba.JiebaCusDictSegmenter;
import com.sdyc.ndmp.cls.dtd.Condition;
import scala.Tuple2;

import java.util.*;

/**
 * <pre>
 *
 * Created by zhenqin.
 * User: zhenqin
 * Date: 17/7/14
 * Time: 10:04
 * Vendor: NowledgeData
 * To change this template use File | Settings | File Templates.
 *
 * </pre>
 *
 * @author zhenqin
 */
public class ContainsKeywordFilter implements Filter {


    /**
     * 匹配条件
     */
    protected final Condition condition;


    /**
     * 多个条件直接的与或非
     */
    protected final Match match;


    /**
     * 默认为 ANY
     * @param condition
     */
    public ContainsKeywordFilter(Condition condition) {
        this(Match.MATCH_ANY, condition);
    }


    public ContainsKeywordFilter(Match match, Condition condition) {
        this.match = match;
        this.condition = condition;
    }


    @Override
    public boolean accept(DataKeywords post) {
        // 获取句子所有的分词
        Set<String> allwords = post.getKeywordRange().keySet();
        if(allwords.isEmpty()) {
            return false;
        }

        Map<String, Set<String>> rule = condition.getRule();
        boolean contains_any =  true;  // 是否包含主题词的任意
        boolean hasWords = false;      // 是否包含主题词

        for (Map.Entry<String, Set<String>> entry : rule.entrySet()) {
            // 获取主体词集合
            Set<String> keyword = entry.getValue();
            // 先判断keyword是否为空
            if(keyword == null || keyword.isEmpty()) {
                // 如果为空，给它赋一个空值
                continue;
            }

            Set<String> _all = new HashSet<>(allwords);

            //排除词，后面处理
            if(!"excludeWord".equals(entry.getKey())) {
                hasWords = true;
                //包含下面任意一个，则通过
                _all.retainAll(keyword);

                //包含任意词，则通过； 后面匹配排除词
                if(_all.isEmpty()) {
                    // 不包含任意词，则直接不通过，不用关心排除词
                    return false;
                }
            }
        }

        // 如果没有主题词，只有排除词，则只认排除

        // 获取排除词
        Set<String> excludeWord = rule.get("excludeWord");
        // 如果上面的条件符合，排除词为 null 则说明没有排除词，返回通过 true
        if(excludeWord == null || excludeWord.isEmpty()) {
            // 排除词为 null，通过 true
            return hasWords;
        }

        Set<String> _all = new HashSet<>(allwords);
        //排除词，不包含任意一个
        _all.retainAll(excludeWord);
        //交集不为空的，则包含排除词，不通过
        //交集为 null，则不包含排除次，通过
        return  _all.isEmpty();
    }


    public static void main(String[] args) {
        Set<String> result = new HashSet<String>();
        Set<String> set1 = new HashSet<String>(){{
            add("a");
            add("b");
            add("c");
        }};

        Set<String> set2 = new HashSet<String>(){{
            add("d");
            add("e");
        }};

        result.clear();
        result.addAll(set1);
        System.out.println("去重复交集前1："+set1);
        System.out.println("去重复交集前2："+set2);

        result.retainAll(set2);
        System.out.println("set1与set2的交集是："+result);

    }

}
